Basic Object implementing FUnknown. More...
#include "pluginterfaces/base/funknown.h"
#include "pluginterfaces/base/iupdatehandler.h"
#include "base/source/fdebug.h"
Data Structures | |
class | FObject |
Implements FUnknown and IDependent. More... | |
Namespaces | |
namespace | Steinberg |
namespace | Steinberg::Singleton |
Automatic creation and destruction of singleton instances. | |
Defines | |
#define | SINGLETON(ClassName) |
#define | OBJ_METHODS(className, baseClass) |
#define | REFCOUNT_METHODS(BaseClass) |
Delegate refcount functions to BaseClass. | |
Macros to implement FUnknown::queryInterface (). | |
class Foo : public FObject, public IFoo2, public IFoo3 { ... DEFINE_INTERFACES DEF_INTERFACE (IFoo2) DEF_INTERFACE (IFoo3) END_DEFINE_INTERFACES (FObject) REFCOUNT_METHODS(FObject) // Implement IFoo2 interface ... // Implement IFoo3 interface ... ... }; | |
#define | DEFINE_INTERFACES |
Start defining interfaces. | |
#define | DEF_INTERFACE(InterfaceName) QUERY_INTERFACE (iid, obj, InterfaceName::iid, InterfaceName) |
Add a interfaces. | |
#define | END_DEFINE_INTERFACES(BaseClass) |
End defining interfaces. | |
Convenient macros to implement Steinberg::FUnknown::queryInterface (). | |
class Foo : public FObject, public IFoo2, public IFoo3 { ... DEF_INTERFACES_2(IFoo2,IFoo3,FObject) REFCOUNT_METHODS(FObject) ... }; | |
#define | DEF_INTERFACES_1(InterfaceName, BaseClass) |
#define | DEF_INTERFACES_2(InterfaceName1, InterfaceName2, BaseClass) |
#define | DEF_INTERFACES_3(InterfaceName1, InterfaceName2, InterfaceName3, BaseClass) |
#define | DEF_INTERFACES_4(InterfaceName1, InterfaceName2, InterfaceName3, InterfaceName4, BaseClass) |
Convenient macros to implement Steinberg::FUnknown methods. | |
class Foo : public FObject, public IFoo2, public IFoo3 { ... FUNKNOWN_METHODS2(IFoo2,IFoo3,FObject) ... }; | |
#define | FUNKNOWN_METHODS(InterfaceName, BaseClass) |
#define | FUNKNOWN_METHODS2(InterfaceName1, InterfaceName2, BaseClass) |
#define | FUNKNOWN_METHODS3(InterfaceName1, InterfaceName2, InterfaceName3, BaseClass) |
#define | FUNKNOWN_METHODS4(InterfaceName1, InterfaceName2, InterfaceName3, InterfaceName4, BaseClass) |
Typedefs | |
typedef FIDString | FClassID |
Functions | |
template<class C > | |
C * | FCast (const FObject *object) |
FCast overload 1 - FObject to FObject. | |
template<class C > | |
C * | FCast (FUnknown *unknown) |
FCast overload 2 - FUnknown to FObject. | |
template<class C > | |
C * | FUCast (FObject *object) |
FUCast - casting from FUnknown to Interface. | |
template<class C > | |
C * | FUCast (FUnknown *object) |
template<class T > | |
void | AssignShared (T *&dest, T *newPtr) |
template<class T > | |
void | AssignSharedDependent (IDependent *_this, T *&dest, T *newPtr) |
template<class T > | |
void | AssignSharedDependent (IDependent *_this, IPtr< T > &dest, T *newPtr) |
template<class T > | |
void | SafeReleaseDependent (IDependent *_this, T *&dest) |
template<class T > | |
void | SafeReleaseDependent (IDependent *_this, IPtr< T > &dest) |
void | registerInstance (FObject **o) |
Registers a instance (type FObject). | |
bool | isTerminated () |
Returns true when singleton instances were already released. | |
Convenience methods that call release or delete respectively | |
on a pointer if it is non-zero, and then set the pointer to zero. Note: you should prefer using IPtr or OPtr instead of these methods whenever possible. Examples: ~Foo () { // instead of ... if (somePointer) { somePointer->release (); somePointer = 0; } // ... just being lazy I write SafeRelease (somePointer) } | |
template<class I > | |
void | SafeRelease (I *&ptr) |
template<class I > | |
void | SafeRelease (IPtr< I > &ptr) |
template<class T > | |
void | SafeDelete (T *&ptr) |
Basic Object implementing FUnknown.
#define SINGLETON | ( | ClassName | ) |
static ClassName* instance (bool create = true) \ { \ static Steinberg::FObject* inst = 0; \ if (inst == 0 && create && Steinberg::Singleton::isTerminated () == false) \ { \ inst = NEW ClassName; \ Steinberg::Singleton::registerInstance (&inst); \ } \ return (ClassName*)inst; \ }
#define OBJ_METHODS | ( | className, | |||
baseClass | ) |
static inline Steinberg::FClassID getFClassID () {return (#className);} \ virtual Steinberg::FClassID isA () const {return className::getFClassID ();} \ virtual bool isA (Steinberg::FClassID s) const {return isTypeOf (s, false);} \ virtual bool isTypeOf (Steinberg::FClassID s, bool askBaseClass = true) const \ { return (classIDsEqual (s, #className) ? true : (askBaseClass ? baseClass::isTypeOf (s, true) : false)); }
#define REFCOUNT_METHODS | ( | BaseClass | ) |
virtual Steinberg::uint32 PLUGIN_API addRef (){ return BaseClass::addRef (); } \ virtual Steinberg::uint32 PLUGIN_API release (){ return BaseClass::release (); }
Delegate refcount functions to BaseClass.
BaseClase must implement ref counting.
#define DEFINE_INTERFACES |
Steinberg::tresult PLUGIN_API queryInterface (const Steinberg::TUID iid, void** obj) \ {
Start defining interfaces.
#define DEF_INTERFACE | ( | InterfaceName | ) | QUERY_INTERFACE (iid, obj, InterfaceName::iid, InterfaceName) |
Add a interfaces.
#define END_DEFINE_INTERFACES | ( | BaseClass | ) |
return BaseClass::queryInterface (iid, obj); \
}
End defining interfaces.
#define DEF_INTERFACES_1 | ( | InterfaceName, | |||
BaseClass | ) |
DEFINE_INTERFACES \ DEF_INTERFACE (InterfaceName) \ END_DEFINE_INTERFACES (BaseClass)
#define DEF_INTERFACES_2 | ( | InterfaceName1, | |||
InterfaceName2, | |||||
BaseClass | ) |
DEFINE_INTERFACES \ DEF_INTERFACE (InterfaceName1) \ DEF_INTERFACE (InterfaceName2) \ END_DEFINE_INTERFACES (BaseClass)
#define DEF_INTERFACES_3 | ( | InterfaceName1, | |||
InterfaceName2, | |||||
InterfaceName3, | |||||
BaseClass | ) |
DEFINE_INTERFACES \ DEF_INTERFACE (InterfaceName1) \ DEF_INTERFACE (InterfaceName2) \ DEF_INTERFACE (InterfaceName3) \ END_DEFINE_INTERFACES (BaseClass)
#define DEF_INTERFACES_4 | ( | InterfaceName1, | |||
InterfaceName2, | |||||
InterfaceName3, | |||||
InterfaceName4, | |||||
BaseClass | ) |
DEFINE_INTERFACES \ DEF_INTERFACE (InterfaceName1) \ DEF_INTERFACE (InterfaceName2) \ DEF_INTERFACE (InterfaceName3) \ DEF_INTERFACE (InterfaceName4) \ END_DEFINE_INTERFACES (BaseClass)
#define FUNKNOWN_METHODS | ( | InterfaceName, | |||
BaseClass | ) |
DEF_INTERFACES_1(InterfaceName,BaseClass) \ REFCOUNT_METHODS(BaseClass)
#define FUNKNOWN_METHODS2 | ( | InterfaceName1, | |||
InterfaceName2, | |||||
BaseClass | ) |
DEF_INTERFACES_2(InterfaceName1,InterfaceName2,BaseClass) \ REFCOUNT_METHODS(BaseClass)
#define FUNKNOWN_METHODS3 | ( | InterfaceName1, | |||
InterfaceName2, | |||||
InterfaceName3, | |||||
BaseClass | ) |
DEF_INTERFACES_3(InterfaceName1,InterfaceName2,InterfaceName3,BaseClass) \ REFCOUNT_METHODS(BaseClass)
#define FUNKNOWN_METHODS4 | ( | InterfaceName1, | |||
InterfaceName2, | |||||
InterfaceName3, | |||||
InterfaceName4, | |||||
BaseClass | ) |
DEF_INTERFACES_4(InterfaceName1,InterfaceName2,InterfaceName3,InterfaceName4,BaseClass) \ REFCOUNT_METHODS(BaseClass)